export default {

    // 定义一个新的 action 从 Dexie 加载数据
    async loadDataFromDexie({ commit }) {
        try {
            const allData = await this._vm.$db.real_market_dingding.toArray();
            const dataFromDexie_contact = await this._vm.$db.contact_dingding.toArray();

            let dataFromDexie = [];
            console.log(allData.length)
            if (allData.length > 40000) {
                console.log('allData 长度超过 40000');
                // 计算三天前的时间戳
                const threeDaysAgo = new Date();
                threeDaysAgo.setDate(threeDaysAgo.getDate() - 3);
                // 过滤出最近三天的信息
                dataFromDexie = allData.filter(item => {
                    const itemDate = new Date(item.timestamp);
                    return itemDate >= threeDaysAgo;
                });

                // 删除旧的信息
                const oldData = allData.filter(item => {
                    const itemDate = new Date(item.timestamp);
                    return itemDate < threeDaysAgo;
                });
                if (oldData.length > 0) {
                    const oldDataIds = oldData.map(item => item.msg_id); // 假设每条记录有唯一的 'id'
                    await this._vm.$db.real_market_dingding.bulkDelete(oldDataIds);
                }
            }
            else{
                dataFromDexie = allData;
            }



            if (dataFromDexie.length == 0) {
                console.log('没有数据，从服务器加载')
            }
            else{
                commit('initContacts', dataFromDexie_contact);
                commit('initMsgListByList', dataFromDexie,0);
            }



        } catch (error) {
            console.error('从 Dexie 加载数据时出错:', error);
        }
    },

    // 定义一个 action 来从 SSE 服务获取数据
    fetchMessages({ commit,dispatch  }) {
        let eventSource;
        let reconnectInterval = 5000; // 重连间隔时间，例如5秒

        const startEventSource = () => {
            // 创建一个新的 EventSource 实例来连接到 SSE 服务
            eventSource = new EventSource('/dingding_new_message');

            // 监听消息
            eventSource.onmessage = (event) => {
                // 检查是否为心跳消息
                if (event.data === ":heartbeat") {
                    console.log("心跳消息接收，连接保持活动状态");
                } else {
                    // 处理实际消息
                    try {
                        const data = JSON.parse(JSON.parse(event.data)[2]);
                        commit('updateMsgListBySigleMsg', data); // 更新 Vuex 状态
                        console.log(data)
                        this._vm.$db.real_market_dingding.put(data).then(() => {
                            console.log('数据成功保存到 Dexie:', data);
                        }).catch(error => {
                            console.error('保存或更新 Dexie 记录时出错:', error);
                        });

                    } catch (e) {
                        console.error("解析消息时出错:", e);
                    }
                }
            };

            // 监听错误
            eventSource.onerror = function(error) {
                console.error('Error with SSE:', error);
                // 在出现错误时关闭 EventSource
                if (eventSource) eventSource.close();
                // 在指定的重连间隔后尝试重新连接
                setTimeout(() => startEventSource(), reconnectInterval);

                // 调用 initDingDingNews 函数
                dispatch('initDingDingNews').then(() => {
                    console.log('从 initDingDingNews 重新加载数据');
                }).catch(error => {
                    console.error('调用 initDingDingNews 时出错:', error);
                });

            };
        };

        // 初始连接
        startEventSource();
    }
    ,
    // 定义一个 action 来从 SSE 服务获取数据
    fetchDavMessages({ commit  }) {
        let eventSource;
        let reconnectInterval = 5000; // 重连间隔时间，例如5秒

        const startEventSource = () => {
            // 创建一个新的 EventSource 实例来连接到 SSE 服务
            eventSource = new EventSource('/init_dav_suggestion');

            // 监听消息
            eventSource.onmessage = (event) => {
                // 检查是否为心跳消息
                if (event.data === ":heartbeat") {
                    console.log("心跳消息接收，连接保持活动状态");
                } else {
                    // 处理实际消息
                    const data = JSON.parse(JSON.parse(event.data)[2]);
                    console.log(data)
                    commit('updateDavSuggestion', data); // 更新 Vuex 状态

                }
            };

            // 监听错误
            eventSource.onerror = function(error) {
                console.error('Error with SSE:', error);
                // 在出现错误时关闭 EventSource
                if (eventSource) eventSource.close();
                // 在指定的重连间隔后尝试重新连接
                setTimeout(() => startEventSource(), reconnectInterval);
            };
        };

        // 初始连接
        startEventSource();
    }
    ,
    initDingDingNews({commit, state  }) {
        let reconnectInterval = 3600*1000; // 重连间隔时间，例如5秒
        const lastRequestTime = parseInt(localStorage.getItem('lastRequestTime'), 10);
        var qurey_url = "/init_dingding_news"
        if (lastRequestTime) {
            const currentTime = Date.now();
            console.log('请求间隔:', currentTime - lastRequestTime);
            if (currentTime - lastRequestTime > reconnectInterval) {
                console.log('距离上次请求时间超过 1 小时，重新请求init_dingding_news');
            }
            else{
                console.log('距离上次请求时间不超过 1 小时，请求init_dingding_recent_news');
                qurey_url = "/init_dingding_recent_news"
            }
        }


        fetch(qurey_url)
            .then(response => {
                if (!response.ok) {
                    throw new Error('网络响应错误');
                }
                return response.json();
            })
            .then(data => {
                let list = data["data"].map(item => JSON.parse(item));

                console.log("初始化历史消息条数:"+list.length)

                let new_msg_list = []
                list.forEach(new_msg => {
                    // 检查是否有与new_msg的author相同但msg_id不同的消息
                    let exists = state.msgList.baseMsg.some(item =>
                        item.group_name === new_msg.author &&
                        item.msg.some(innerItem => innerItem.msg_id === new_msg.msg_id));

                    // 如果不存在，则添加到new_msg_list中
                    if (!exists) {
                        new_msg_list.push(new_msg);
                        state.current_msg = new_msg;
                    }
                });
                console.log(new_msg_list)
                commit('updateMsgListByList', new_msg_list); // 如果你需要更新 Vuex 状态

                // 存储数据到 Dexie 数据库
                    // 存储或更新数据到 Dexie 数据库
                new_msg_list.forEach(item => {
                        // 检查是否存在具有相同 msg_id 的记录
                        this._vm.$db.real_market_dingding.put(item).then(() => {
                        }).catch(error => {
                            console.error('保存或更新 Dexie 记录时出错:', error);
                        });
                    });
                console.log('初始化完成');
                state.loadingComplete = true;

                if (qurey_url == "/init_dingding_news") {
                    localStorage.setItem('lastRequestTime', Date.now().toString());
                }

            })
            .catch(error => {
                console.error('initMsgList 时出错:', error);
            });
    },

    initDavSuggestion() {
        fetch('/init_dav_suggestion')
            .then(response => {
                if (!response.ok) {
                    throw new Error('网络响应错误');
                }
                return response.json();
            })
            .then(data => {
                let list = data["data"].map(item => JSON.parse(item));
                console.log(list)
            })
            .catch(error => {
                console.error('initMsgList 时出错:', error);
            });
    },

    // 可以在这里添加更多的 actions
    updateSearchIpt({ commit }, value) {
        commit('setSearchIpt', value);
    },
    updateDisplayType({ commit }, value) {
        commit('setDisplayType', value);
    }
};
